﻿using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace AutoUpdate.register
{
    /// <summary>  
    /// 注册表操作类  
    ///1.创建注册表项  
    ///2.读取注册表项  
    ///3.判断注册表项是否存在  
    ///4.删除注册表项  
    ///5.创建注册表键值  
    ///6.读取注册表键值  
    ///7.判断注册表键值是否存在  
    ///8.删除注册表键值  
    /// </summary>  
    public class Register
    {
       
        #region 字段定义  

        /// <summary>  
        /// 注册表项名称  
        /// </summary>  
        private string _subkey;
        /// <summary>  
        /// 注册表基项域  
        /// </summary>  
        private RegDomain _domain;

        #endregion

        #region 构造函数  

        public Register()
        {
            ///默认注册表项名称  
            _subkey = "software\\";
            ///默认注册表基项域  
            _domain = RegDomain.LocalMachine;
        }

        /// <summary>  
        /// 构造函数  
        /// </summary>  
        /// <param name="subKey">注册表项名称</param>  
        /// <param name="regDomain">注册表基项域</param>  
        public Register(string subKey, RegDomain regDomain)
        {
            ///设置注册表项名称  
            if (string.IsNullOrWhiteSpace(subKey))
                throw new Exception("subKey不能是空");
            _subkey = subKey;
            ///设置注册表基项域  
            _domain = regDomain;
        }

        #endregion

        #region 注册表项相关操作

        /// <summary>  
        /// 创建注册表项，默认创建在注册表基项 HKEY_LOCAL_MACHINE 下面
        /// </summary>  
        public virtual void CreateSubKey()
        {
            ///创建基于注册表基项的节点  
            RegistryKey key = GetRegDomain(_domain);
            ///要创建的注册表项的节点  
            if (!IsSubKeyExist())
            {
                key.CreateSubKey(_subkey);
            }
            ///关闭对注册表项的更改  
            key.Close();
        }

        /// <summary>  
        /// 判断注册表项是否存在
        /// 例子：如果设置了Domain 和SubKey 属性，则判断Domain\\SubKey，否则默认判断HKEY_LOCAL_MACHINE\\software\\  
        /// </summary>  
        /// <returns>返回注册表项是否存在，存在返回true，否则返回false</returns>  
        public virtual bool IsSubKeyExist()
        {
            ///检索注册表子项  
            ///如果sKey 为null,说明没有该注册表项不存在，否则存在  
            RegistryKey sKey = OpenSubKey();
            return sKey != null;
        }


        /// <summary>  
        /// 删除注册表项 
        /// 虚方法，子类可进行重写  
        /// </summary>  
        /// <returns>如果删除成功，则返回true，否则为false</returns>  
        public virtual void DeleteSubKey()
        {

            ///创建基于注册表基项的节点  
            RegistryKey key = GetRegDomain(_domain);

            if (IsSubKeyExist())
            {
                key.DeleteSubKey(_subkey);
            }
            ///关闭对注册表项的更改  
            key.Close();
        }
        #endregion

        #region 读写键值相关方法

        /// <summary>  
        /// 判断键值是否存在 
        /// </summary>  
        /// <param name="name">键值名称</param>  
        /// <returns>返回键值是否存在，存在返回true，否则返回false</returns>  
        public virtual bool IsRegeditKeyExist(string name)
        {
            ///返回结果  
            bool result = false;

            ///判断是否设置键值属性  
            if (string.IsNullOrWhiteSpace(name))
            {
                throw new Exception("name参数不能是空");
            }

            ///判断注册表项是否存在  
            if (IsSubKeyExist())
            {
                ///打开注册表项  
                RegistryKey key = OpenSubKey();
                ///键值集合  
                string[] regeditKeyNames;
                ///获取键值集合  
                regeditKeyNames = key.GetValueNames();
                ///遍历键值集合，如果存在键值，则退出遍历  
                foreach (string regeditKey in regeditKeyNames)
                {
                    if (string.Compare(regeditKey, name, true) == 0)
                    {
                        result = true;
                        break;
                    }
                }
                ///关闭对注册表项的更改  
                key.Close();
            }
            return result;
        }

        /// <summary>  
        /// 设置指定的键值内容，不指定内容数据类型（请先设置SubKey 属性）  
        /// 存在改键值则修改键值内容，不存在键值则先创建键值，再设置键值内容  
        /// </summary>  
        /// <param name="name">键值名称</param>  
        /// <param name="content">键值内容</param>  
        /// <returns>键值内容设置成功，则返回true，否则返回false</returns>  
        public virtual void WriteRegeditKey(string name, object content)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                throw new Exception("name参数不能是空");
            }

            ///判断注册表项是否存在，如果不存在，则直接创建  
            if (!IsSubKeyExist())
            {
                CreateSubKey();
            }

            ///以可写方式打开注册表项  
            RegistryKey key = OpenSubKey(true);
            if (key == null)
            {
                throw new Exception("注册表项打开失败");
            }

            try
            {
                key.SetValue(name, content);
            }
            finally
            {
                ///关闭对注册表项的更改  
                key.Close();
            }
        }

        /// <summary>  
        /// 设置指定的键值内容，指定内容数据类型（请先设置SubKey 属性）  
        /// 存在改键值则修改键值内容，不存在键值则先创建键值，再设置键值内容  
        /// </summary>  
        /// <param name="name">键值名称</param>  
        /// <param name="content">键值内容</param>  
        /// <returns>键值内容设置成功，则返回true，否则返回false</returns>  
        public virtual void WriteRegeditKey(string name, object content, RegistryValueKind regValueKind)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                throw new Exception("name参数不能是空");
            }

            ///判断注册表项是否存在，如果不存在，则直接创建  
            if (!IsSubKeyExist())
            {
                CreateSubKey();
            }

            ///以可写方式打开注册表项  
            RegistryKey key = OpenSubKey(true);
            if (key == null)
            {
                throw new Exception("注册表项打开失败");
            }

            try
            {
                key.SetValue(name, content, regValueKind);
            }
            finally
            {
                ///关闭对注册表项的更改  
                key.Close();
            }
        }


        /// <summary>  
        /// 读取键值内容（请先设置SubKey 属性）  
        /// .如果SubKey 为空、null 或者SubKey 指示的注册表项不存在，返回null  
        /// .反之，则返回键值内容  
        /// </summary>  
        /// <param name="name">键值名称</param>  
        /// <returns>返回键值内容</returns>  
        public virtual object ReadRegeditKey(string name)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                throw new Exception("name参数不能是空");
            }

            ///判断键值是否存在  
            if (IsRegeditKeyExist(name))
            {
                ///打开注册表项  
                RegistryKey key = OpenSubKey();
                if (key == null)
                {
                    throw new Exception("打开注册表项失败");
                }
                return key.GetValue(name);
            }
            return null;
        }

        /// <summary>  
        /// 删除键值（请先设置SubKey 属性）  
        /// 如果SubKey 为空、null 或者SubKey 指示的注册表项不存在，返回false  
        /// </summary>  
        /// <param name="name">键值名称</param>  
        /// <returns>如果删除成功，返回true，否则返回false</returns>  
        public virtual void DeleteRegeditKey(string name)
        {
            ///判断键值名称是否为空，如果为空，则返回false  
            if (string.IsNullOrWhiteSpace(name))
            {
                throw new Exception("name参数不能是空");
            }

            ///判断键值是否存在  
            if (!IsRegeditKeyExist(name))
            {
                return;
            }
            ///以可写方式打开注册表项  
            RegistryKey key = OpenSubKey(true);
            if (key == null)
            {
                throw new Exception("打开注册表项失败");
            }
            try
            {
                ///删除键值  
                key.DeleteValue(name);
            }
            finally
            {
                ///关闭对注册表项的更改  
                key.Close();
            }

        }

        #endregion

        #region 受保护方法  

        /// <summary>  
        /// 获取注册表基项域对应顶级节点  
        /// 例子：如regDomain 是ClassesRoot，则返回Registry.ClassesRoot  
        /// </summary>  
        /// <param name="regDomain">注册表基项域</param>  
        /// <returns>注册表基项域对应顶级节点</returns>  
        protected RegistryKey GetRegDomain(RegDomain regDomain)
        {
            ///创建基于注册表基项的节点  
            RegistryKey key;

            #region 判断注册表基项域  
            switch (regDomain)
            {
                case RegDomain.ClassesRoot:
                    key = Registry.ClassesRoot; break;
                case RegDomain.CurrentUser:
                    key = Registry.CurrentUser; break;
                case RegDomain.LocalMachine:
                    key = Registry.LocalMachine; break;
                case RegDomain.User:
                    key = Registry.Users; break;
                case RegDomain.CurrentConfig:
                    key = Registry.CurrentConfig; break;
                case RegDomain.PerformanceData:
                    key = Registry.PerformanceData; break;
                default:
                    key = Registry.LocalMachine; break;
            }
            #endregion

            return key;
        }

        #region 打开注册表项  

        /// <summary>  
        /// 打开注册表项节点，以只读方式检索子项  
        /// 虚方法，子类可进行重写  
        /// </summary>  
        /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在，则返回null，否则返回注册表节点</returns>  
        RegistryKey OpenSubKey()
        {
            return OpenSubKey(false);
        }

        /// <summary>  
        /// 打开注册表项节点  
        /// 虚方法，子类可进行重写  
        /// </summary>  
        /// <param name="writable">如果需要项的写访问权限，则设置为 true</param>  
        /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在，则返回null，否则返回注册表节点</returns>  
        RegistryKey OpenSubKey(bool writable)
        {
            ///创建基于注册表基项的节点  
            RegistryKey key = GetRegDomain(_domain);
            ///打开注册表项  
            RegistryKey sKey = key.OpenSubKey(_subkey, writable);
            ///关闭对注册表项的更改  
            key.Close();
            ///返回注册表节点  
            return sKey;
        }

        #endregion

        #endregion
    }

}
